//: [Previous](@previous)

import Foundation

var str = "Hello, playground"

//================赋值运算符=====================

let b = 10
var a = 5
a = b
// a 的值现在是 10


let (x, y) = (1, 2)
// x 等于 1, 同时 y 等于 2


//Swift 的赋值符号自身不会返回值。下面的语句是不合法的：
/*
if x = y {
    // 这是不合法的, 因为 x = y 并不会返回任何值。
}
*/

//================算术运算符=====================

1 + 2 // equals 3
5 - 3 // equals 2
2 * 3 // equals 6
10.0 / 2.5 // equals 4.0

// 加法运算符同时也支持 String  的拼接：

"hello, " + "world"
// equals "hello, world"



let name = "world"
if name == "world" {
    print("hello, world")
} else {
    print("I'm sorry \(name), but I don't recognize you")
}
// 输出“hello, world", 因为 `name` 就是等于 "world”


// ===============余数运算符======================

9 % 4 // equals 1
// 即 9 = 4*2 + 1

//  ===============一元减号运算符======================


let three = 3
let minusThree = -three // minusThree equals -3
let plusThree = -minusThree // plusThree equals 3, or "minus minus three"


//  ===============一元加号运算符======================
let minusSix = -6
let alsoMinusSix = +minusSix // alsoMinusSix equals -6



//  =============== 组合赋值符号======================

var a1 = 1
a1 += 2
// 即 a = a + 2

var b1 = 1
b1 -= 1
// 即 b = b - 1

print("a=\(a1),b=\(b1)")

//  ===============比较运算符======================
// 等于 a == b
// 不等于 a != b
// 大于 a > b
// 小于 a < b
// 大于等于 a >= b
// 小于等于 a <= b
(1, "zebra") < (2, "apple")   // true，因为 1 小于 2
(3, "apple") < (3, "bird")    // true，因为 3 等于 3，但是 apple 小于 bird
(4, "dog") == (4, "dog")      // true，因为 4 等于 4，dog 等于 dog


//  ===============一三元运算符======================

let contentHeight = 40
let hasHeader = true
let rowHeight = contentHeight + (hasHeader ? 50 : 20)




// 空合运算符

let defaultColor = "red"
var color: String?   //默认值为 nil

var nowColor = color ?? defaultColor
print(nowColor)

//  ===============区间运算符======================

//闭区间运算符: a...b 包含两端
for index in 1...5 {
    print("\(index) * 5 = \(index * 5)")
}
// 1 * 5 = 5
// 2 * 5 = 10
// 3 * 5 = 15
// 4 * 5 = 20
// 5 * 5 = 25


//半开区间运算符: a..<b, 包含a，但是不包含b
let names = ["Anna", "Alex", "Brian", "Jack"]
let count = names.count
for i in 0..<count {
    print("第 \(i + 1) 个人叫 \(names[i])")
}
// 第 1 个人叫 Anna
// 第 2 个人叫 Alex
// 第 3 个人叫 Brian
// 第 4 个人叫 Jack


//单侧区间: 可以往一侧无限延伸的区间
//例如，一个包含了数组从索引 2 到结尾的所有值的区间。
for name in names[2...] {
    print(name)
}
// Brian
// Jack

for name in names[...2] {
    print(name)
}
// Anna
// Alex
// Brian

for name in names[..<2] {
    print(name)
}
// Anna
// Alex

//  ===============逻辑运算符======================

/*
**逻辑运算符的操作对象是逻辑布尔值。**

- 逻辑非（`!a`）:  操作数前没有空格，对一个布尔值取反

- 逻辑与（`a && b`）： 真真为真，否则为假，存在短路计算

- 逻辑或（`a || b`）： 有一个为真即为真，存在短路计算

*/

//=============== 类和结构体可以为现有的运算符提供自定义的实现，被称为**运算符重载**。 ======================
prefix operator +++

struct Vector2D {
    var x = 0.0, y = 0.0
}

extension Vector2D {
    static func + (left: Vector2D, right: Vector2D) -> Vector2D {
        return Vector2D(x: left.x + right.x, y: left.y + right.y)
    }

		static prefix func - (vector: Vector2D) -> Vector2D {
				return Vector2D(x: -vector.x, y: -vector.y)
		}
		static func += (left: inout Vector2D, right: Vector2D) {
				left = left + right
		}
		static prefix func +++ (vector: inout Vector2D) -> Vector2D {
				//+= 同样是重载过的
				vector += vector
				return vector
		}
}

let vector = Vector2D(x: 3.0, y: 1.0)
let anotherVector = Vector2D(x: 2.0, y: 4.0)
let combinedVector = vector + anotherVector
// 输出： Vector2D(x: 5.0, y: 5.0)
print(combinedVector)

let positive = Vector2D(x: 3.0, y: 4.0)
let negative = -positive
// 输出： Vector2D(x: -3.0, y: -4.0)
print(negative)


var toBeDoubled = Vector2D(x: 1.0, y: 4.0)
let afterDoubling = +++toBeDoubled
// toBeDoubled 和 afterDoubling 输出：Vector2D(x: 2.0, y: 8.0)
print(toBeDoubled)
print(afterDoubling)

//: [Next](@next)
